// $ANTLR 3.1.2 E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g 2013-05-14 21:10:36

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 219
// Unreachable code detected.
#pragma warning disable 162


	using ActorModel.Infrastructure;
	using ActorModel.Infrastructure.Configuration.Ivashenko.Helpers;


using System.Collections.Generic;
using Antlr.Runtime;
using Stack = System.Collections.Generic.Stack<object>;
using List = System.Collections.IList;
using ArrayList = System.Collections.Generic.List<object>;

namespace ActorModel.Infrastructure.Configuration.Ivashenko.Grammar
{
public partial class IvashenkoConfigParser : Parser
{
	internal static readonly string[] tokenNames = new string[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "ASSIGN", "COLON", "COMMENT", "CONNECTORS_PER_NODE_COUNT", "DEFAULT_STATE", "INT", "LEFT_BRACKET", "NODES_COUNT", "RIGHT_BRACKET", "SEMI", "STRING", "WS"
	};
	public const int EOF=-1;
	public const int ASSIGN=4;
	public const int COLON=5;
	public const int COMMENT=6;
	public const int CONNECTORS_PER_NODE_COUNT=7;
	public const int DEFAULT_STATE=8;
	public const int INT=9;
	public const int LEFT_BRACKET=10;
	public const int NODES_COUNT=11;
	public const int RIGHT_BRACKET=12;
	public const int SEMI=13;
	public const int STRING=14;
	public const int WS=15;

	// delegates
	// delegators

	public IvashenkoConfigParser( ITokenStream input )
		: this( input, new RecognizerSharedState() )
	{
	}
	public IvashenkoConfigParser( ITokenStream input, RecognizerSharedState state )
		: base( input, state )
	{
	}
		

	public override string[] TokenNames { get { return IvashenkoConfigParser.tokenNames; } }
	public override string GrammarFileName { get { return "E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g"; } }


	#region Rules
	protected class configuration_scope
	{
		public EngineStartParameters<string> startParameters;
	}
	partial void configuration_scopeInit( configuration_scope scope );partial void configuration_scopeAfter( configuration_scope scope );protected Stack<configuration_scope> configuration_stack = new Stack<configuration_scope>();


	// $ANTLR start "configuration"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:15:0: public configuration returns [EngineStartParameters<string> parameters] : ( setup_option SEMI )+ EOF ;
	public EngineStartParameters<string> configuration(  )
	{
		configuration_stack.Push(new configuration_scope());configuration_scopeInit(configuration_stack.Peek());
		EngineStartParameters<string> parameters = default(EngineStartParameters<string>);


			((configuration_scope)configuration_stack.Peek()).startParameters = new EngineStartParameters<string>();

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:24:4: ( ( setup_option SEMI )+ EOF )
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:24:4: ( setup_option SEMI )+ EOF
			{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:24:4: ( setup_option SEMI )+
			int cnt1=0;
			for ( ; ; )
			{
				int alt1=2;
				int LA1_0 = input.LA(1);

				if ( ((LA1_0>=CONNECTORS_PER_NODE_COUNT && LA1_0<=NODES_COUNT)) )
				{
					alt1=1;
				}


				switch ( alt1 )
				{
				case 1:
					// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:24:5: setup_option SEMI
					{
					PushFollow(Follow._setup_option_in_configuration60);
					setup_option();

					state._fsp--;

					Match(input,SEMI,Follow._SEMI_in_configuration62); 

					}
					break;

				default:
					if ( cnt1 >= 1 )
						goto loop1;

					EarlyExitException eee1 = new EarlyExitException( 1, input );
					throw eee1;
				}
				cnt1++;
			}
			loop1:
				;


			Match(input,EOF,Follow._EOF_in_configuration66); 

					parameters = ((configuration_scope)configuration_stack.Peek()).startParameters;
				

			}

		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			configuration_scopeAfter(configuration_stack.Peek());configuration_stack.Pop();
		}
		return parameters;
	}
	// $ANTLR end "configuration"


	// $ANTLR start "setup_option"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:29:0: setup_option : ( nodes_count_option | connectors_per_node_count_option | connection_option | init_state_option );
	private void setup_option(  )
	{
		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:30:4: ( nodes_count_option | connectors_per_node_count_option | connection_option | init_state_option )
			int alt2=4;
			alt2 = dfa2.Predict(input);
			switch ( alt2 )
			{
			case 1:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:30:4: nodes_count_option
				{
				PushFollow(Follow._nodes_count_option_in_setup_option79);
				nodes_count_option();

				state._fsp--;


				}
				break;
			case 2:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:31:4: connectors_per_node_count_option
				{
				PushFollow(Follow._connectors_per_node_count_option_in_setup_option84);
				connectors_per_node_count_option();

				state._fsp--;


				}
				break;
			case 3:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:32:4: connection_option
				{
				PushFollow(Follow._connection_option_in_setup_option89);
				connection_option();

				state._fsp--;


				}
				break;
			case 4:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:33:4: init_state_option
				{
				PushFollow(Follow._init_state_option_in_setup_option94);
				init_state_option();

				state._fsp--;


				}
				break;

			}
		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return ;
	}
	// $ANTLR end "setup_option"


	// $ANTLR start "nodes_count_option"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:35:0: nodes_count_option : NODES_COUNT ASSIGN INT ;
	private void nodes_count_option(  )
	{
		IToken INT1=null;

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:36:4: ( NODES_COUNT ASSIGN INT )
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:36:4: NODES_COUNT ASSIGN INT
			{
			Match(input,NODES_COUNT,Follow._NODES_COUNT_in_nodes_count_option104); 
			Match(input,ASSIGN,Follow._ASSIGN_in_nodes_count_option106); 
			INT1=(IToken)Match(input,INT,Follow._INT_in_nodes_count_option108); 

					((configuration_scope)configuration_stack.Peek()).startParameters.NumberOfNodes = int.Parse((INT1!=null?INT1.Text:null));
				

			}

		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return ;
	}
	// $ANTLR end "nodes_count_option"


	// $ANTLR start "connectors_per_node_count_option"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:41:0: connectors_per_node_count_option : CONNECTORS_PER_NODE_COUNT ASSIGN INT ;
	private void connectors_per_node_count_option(  )
	{
		IToken INT2=null;

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:42:4: ( CONNECTORS_PER_NODE_COUNT ASSIGN INT )
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:42:4: CONNECTORS_PER_NODE_COUNT ASSIGN INT
			{
			Match(input,CONNECTORS_PER_NODE_COUNT,Follow._CONNECTORS_PER_NODE_COUNT_in_connectors_per_node_count_option121); 
			Match(input,ASSIGN,Follow._ASSIGN_in_connectors_per_node_count_option123); 
			INT2=(IToken)Match(input,INT,Follow._INT_in_connectors_per_node_count_option125); 

					((configuration_scope)configuration_stack.Peek()).startParameters.NumberOfNodeConnectors = int.Parse((INT2!=null?INT2.Text:null));
				

			}

		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return ;
	}
	// $ANTLR end "connectors_per_node_count_option"


	// $ANTLR start "connection_option"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:47:0: connection_option : one= connector COLON other= connector ;
	private void connection_option(  )
	{
		int one = default(int);
		int other = default(int);

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:48:4: (one= connector COLON other= connector )
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:48:4: one= connector COLON other= connector
			{
			PushFollow(Follow._connector_in_connection_option142);
			one=connector();

			state._fsp--;

			Match(input,COLON,Follow._COLON_in_connection_option144); 
			PushFollow(Follow._connector_in_connection_option150);
			other=connector();

			state._fsp--;


					ConnectorInfo<string> connectorInfo;
					if (((configuration_scope)configuration_stack.Peek()).startParameters.ConnectorsInfo.TryGetValue(one, out connectorInfo))
					{
						connectorInfo.TargetConnectorId = other;
					}
					else
					{
						((configuration_scope)configuration_stack.Peek()).startParameters.ConnectorsInfo.Add(one, new ConnectorInfo<string> { TargetConnectorId = other });
					}
				

			}

		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return ;
	}
	// $ANTLR end "connection_option"


	// $ANTLR start "connector"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:61:0: connector returns [int id] : (nodeid= INT LEFT_BRACKET connid= INT RIGHT_BRACKET | LEFT_BRACKET connid= INT RIGHT_BRACKET nodeid= INT );
	private int connector(  )
	{
		int id = default(int);

		IToken nodeid=null;
		IToken connid=null;

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:62:4: (nodeid= INT LEFT_BRACKET connid= INT RIGHT_BRACKET | LEFT_BRACKET connid= INT RIGHT_BRACKET nodeid= INT )
			int alt3=2;
			int LA3_0 = input.LA(1);

			if ( (LA3_0==INT) )
			{
				alt3=1;
			}
			else if ( (LA3_0==LEFT_BRACKET) )
			{
				alt3=2;
			}
			else
			{
				NoViableAltException nvae = new NoViableAltException("", 3, 0, input);

				throw nvae;
			}
			switch ( alt3 )
			{
			case 1:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:62:4: nodeid= INT LEFT_BRACKET connid= INT RIGHT_BRACKET
				{
				nodeid=(IToken)Match(input,INT,Follow._INT_in_connector171); 
				Match(input,LEFT_BRACKET,Follow._LEFT_BRACKET_in_connector173); 
				connid=(IToken)Match(input,INT,Follow._INT_in_connector179); 
				Match(input,RIGHT_BRACKET,Follow._RIGHT_BRACKET_in_connector181); 

						id = (((configuration_scope)configuration_stack.Peek()).startParameters.NumberOfNodeConnectors * int.Parse((nodeid!=null?nodeid.Text:null))) + int.Parse((connid!=null?connid.Text:null));
					

				}
				break;
			case 2:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:66:4: LEFT_BRACKET connid= INT RIGHT_BRACKET nodeid= INT
				{
				Match(input,LEFT_BRACKET,Follow._LEFT_BRACKET_in_connector189); 
				connid=(IToken)Match(input,INT,Follow._INT_in_connector195); 
				Match(input,RIGHT_BRACKET,Follow._RIGHT_BRACKET_in_connector197); 
				nodeid=(IToken)Match(input,INT,Follow._INT_in_connector203); 

						id = (((configuration_scope)configuration_stack.Peek()).startParameters.NumberOfNodeConnectors * int.Parse((nodeid!=null?nodeid.Text:null))) + int.Parse((connid!=null?connid.Text:null));
					

				}
				break;

			}
		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return id;
	}
	// $ANTLR end "connector"


	// $ANTLR start "init_state_option"
	// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:71:0: init_state_option : ( INT ASSIGN STRING | DEFAULT_STATE ASSIGN STRING | connector ASSIGN STRING );
	private void init_state_option(  )
	{
		IToken INT3=null;
		IToken STRING4=null;
		IToken STRING5=null;
		IToken STRING7=null;
		int connector6 = default(int);

		try
		{
			// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:72:4: ( INT ASSIGN STRING | DEFAULT_STATE ASSIGN STRING | connector ASSIGN STRING )
			int alt4=3;
			switch ( input.LA(1) )
			{
			case INT:
				{
				int LA4_1 = input.LA(2);

				if ( (LA4_1==ASSIGN) )
				{
					alt4=1;
				}
				else if ( (LA4_1==LEFT_BRACKET) )
				{
					alt4=3;
				}
				else
				{
					NoViableAltException nvae = new NoViableAltException("", 4, 1, input);

					throw nvae;
				}
				}
				break;
			case DEFAULT_STATE:
				{
				alt4=2;
				}
				break;
			case LEFT_BRACKET:
				{
				alt4=3;
				}
				break;
			default:
				{
					NoViableAltException nvae = new NoViableAltException("", 4, 0, input);

					throw nvae;
				}
			}

			switch ( alt4 )
			{
			case 1:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:72:4: INT ASSIGN STRING
				{
				INT3=(IToken)Match(input,INT,Follow._INT_in_init_state_option216); 
				Match(input,ASSIGN,Follow._ASSIGN_in_init_state_option218); 
				STRING4=(IToken)Match(input,STRING,Follow._STRING_in_init_state_option220); 

						int id = int.Parse((INT3!=null?INT3.Text:null));
						if (((configuration_scope)configuration_stack.Peek()).startParameters.NodesInitialStates.ContainsKey(id))
						{
							((configuration_scope)configuration_stack.Peek()).startParameters.NodesInitialStates.Remove(id);
							((configuration_scope)configuration_stack.Peek()).startParameters.NodesInitialStates.Add(id, (STRING4!=null?STRING4.Text:null).Substring(1, (STRING4!=null?STRING4.Text:null).Length - 2));
						}
						else
						{
							((configuration_scope)configuration_stack.Peek()).startParameters.NodesInitialStates.Add(int.Parse((INT3!=null?INT3.Text:null)), (STRING4!=null?STRING4.Text:null).Substring(1, (STRING4!=null?STRING4.Text:null).Length - 2));
						}
					

				}
				break;
			case 2:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:85:4: DEFAULT_STATE ASSIGN STRING
				{
				Match(input,DEFAULT_STATE,Follow._DEFAULT_STATE_in_init_state_option228); 
				Match(input,ASSIGN,Follow._ASSIGN_in_init_state_option230); 
				STRING5=(IToken)Match(input,STRING,Follow._STRING_in_init_state_option232); 

						((configuration_scope)configuration_stack.Peek()).startParameters.InitDefaultState((STRING5!=null?STRING5.Text:null).Substring(1, (STRING5!=null?STRING5.Text:null).Length - 2));
					

				}
				break;
			case 3:
				// E:\\Documents\\Projects\\CellularAutomaton\\Extensions\\IvashenkoConfigLoader\\Grammar\\IvashenkoConfig.g:89:4: connector ASSIGN STRING
				{
				PushFollow(Follow._connector_in_init_state_option240);
				connector6=connector();

				state._fsp--;

				Match(input,ASSIGN,Follow._ASSIGN_in_init_state_option242); 
				STRING7=(IToken)Match(input,STRING,Follow._STRING_in_init_state_option244); 

						ConnectorInfo<string> connectorInfo;
						if (((configuration_scope)configuration_stack.Peek()).startParameters.ConnectorsInfo.TryGetValue(connector6, out connectorInfo))
						{
							connectorInfo.State = (STRING7!=null?STRING7.Text:null).Substring(1, (STRING7!=null?STRING7.Text:null).Length - 2);
						}
						else
						{
							((configuration_scope)configuration_stack.Peek()).startParameters.ConnectorsInfo.Add(connector6, new ConnectorInfo<string> { State = (STRING7!=null?STRING7.Text:null).Substring(1, (STRING7!=null?STRING7.Text:null).Length - 2) });
						}
					

				}
				break;

			}
		}
		catch ( RecognitionException re )
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
		}
		return ;
	}
	// $ANTLR end "init_state_option"
	#endregion Rules


	#region DFA
	DFA2 dfa2;

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa2 = new DFA2( this );
	}

	class DFA2 : DFA
	{

		const string DFA2_eotS =
			"\xD\xFFFF";
		const string DFA2_eofS =
			"\xD\xFFFF";
		const string DFA2_minS =
			"\x1\x7\x2\xFFFF\x1\x4\x1\x9\x1\xFFFF\x1\x9\x2\xC\x1\x9\x2\x4\x1\xFFFF";
		const string DFA2_maxS =
			"\x1\xB\x2\xFFFF\x1\xA\x1\x9\x1\xFFFF\x1\x9\x2\xC\x1\x9\x2\x5\x1\xFFFF";
		const string DFA2_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x2\xFFFF\x1\x4\x6\xFFFF\x1\x3";
		const string DFA2_specialS =
			"\xD\xFFFF}>";
		static readonly string[] DFA2_transitionS =
			{
				"\x1\x2\x1\x5\x1\x3\x1\x4\x1\x1",
				"",
				"",
				"\x1\x5\x5\xFFFF\x1\x6",
				"\x1\x7",
				"",
				"\x1\x8",
				"\x1\x9",
				"\x1\xA",
				"\x1\xB",
				"\x1\x5\x1\xC",
				"\x1\x5\x1\xC",
				""
			};

		static readonly short[] DFA2_eot = DFA.UnpackEncodedString(DFA2_eotS);
		static readonly short[] DFA2_eof = DFA.UnpackEncodedString(DFA2_eofS);
		static readonly char[] DFA2_min = DFA.UnpackEncodedStringToUnsignedChars(DFA2_minS);
		static readonly char[] DFA2_max = DFA.UnpackEncodedStringToUnsignedChars(DFA2_maxS);
		static readonly short[] DFA2_accept = DFA.UnpackEncodedString(DFA2_acceptS);
		static readonly short[] DFA2_special = DFA.UnpackEncodedString(DFA2_specialS);
		static readonly short[][] DFA2_transition;

		static DFA2()
		{
			int numStates = DFA2_transitionS.Length;
			DFA2_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA2_transition[i] = DFA.UnpackEncodedString(DFA2_transitionS[i]);
			}
		}

		public DFA2( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 2;
			this.eot = DFA2_eot;
			this.eof = DFA2_eof;
			this.min = DFA2_min;
			this.max = DFA2_max;
			this.accept = DFA2_accept;
			this.special = DFA2_special;
			this.transition = DFA2_transition;
		}
		public override string GetDescription()
		{
			return "29:0: setup_option : ( nodes_count_option | connectors_per_node_count_option | connection_option | init_state_option );";
		}
	}


	#endregion DFA

	#region Follow sets
	static class Follow
	{
		public static readonly BitSet _setup_option_in_configuration60 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _SEMI_in_configuration62 = new BitSet(new ulong[]{0xF80UL});
		public static readonly BitSet _EOF_in_configuration66 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _nodes_count_option_in_setup_option79 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _connectors_per_node_count_option_in_setup_option84 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _connection_option_in_setup_option89 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _init_state_option_in_setup_option94 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _NODES_COUNT_in_nodes_count_option104 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ASSIGN_in_nodes_count_option106 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _INT_in_nodes_count_option108 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _CONNECTORS_PER_NODE_COUNT_in_connectors_per_node_count_option121 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ASSIGN_in_connectors_per_node_count_option123 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _INT_in_connectors_per_node_count_option125 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _connector_in_connection_option142 = new BitSet(new ulong[]{0x20UL});
		public static readonly BitSet _COLON_in_connection_option144 = new BitSet(new ulong[]{0x600UL});
		public static readonly BitSet _connector_in_connection_option150 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _INT_in_connector171 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _LEFT_BRACKET_in_connector173 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _INT_in_connector179 = new BitSet(new ulong[]{0x1000UL});
		public static readonly BitSet _RIGHT_BRACKET_in_connector181 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _LEFT_BRACKET_in_connector189 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _INT_in_connector195 = new BitSet(new ulong[]{0x1000UL});
		public static readonly BitSet _RIGHT_BRACKET_in_connector197 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _INT_in_connector203 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _INT_in_init_state_option216 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ASSIGN_in_init_state_option218 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _STRING_in_init_state_option220 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _DEFAULT_STATE_in_init_state_option228 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ASSIGN_in_init_state_option230 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _STRING_in_init_state_option232 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _connector_in_init_state_option240 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ASSIGN_in_init_state_option242 = new BitSet(new ulong[]{0x4000UL});
		public static readonly BitSet _STRING_in_init_state_option244 = new BitSet(new ulong[]{0x2UL});

	}
	#endregion Follow sets
}

} // namespace ActorModel.Infrastructure.Configuration.Ivashenko.Grammar
